/*
 * Created on Mar 27, 2006
 *
 */
package ar.edu.utn.frba.gdaia.src.junittest.AbstraerConceptos;


import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import junit.framework.Test;
import junit.framework.TestSuite;
import ar.edu.utn.frba.gdaia.src.domain.Canal;
import ar.edu.utn.frba.gdaia.src.domain.ConceptoElemental;
import ar.edu.utn.frba.gdaia.src.domain.Regla;
import ar.edu.utn.frba.gdaia.src.domain.Situacion;
import ar.edu.utn.frba.gdaia.src.main.GDAIA;
import ar.edu.utn.frba.gdaia.src.test.TestSetup;
import ar.edu.utn.frba.gdaia.src.util.ListBuilder;


/**
 * @author Fernando
 *
 */
public class TestsAbstraerConceptos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		junit.swingui.TestRunner.run(TestsAbstraerConceptos.class);
	}

	/**
	 * @return a 
	 */
	public static Test suite() {
		TestSetup.main(null);
		System.out.println("Iniciando Suite de Test: Lista Corta");
		TestSuite suite = new TestSuite();
		// $JUnit-BEGIN$

		GDAIA gdaia = new GDAIA();
		gdaia.setCerebro(gdaia.generateCerebroFromXML());

		/*
		TextInterface gui = new ConcreteGUIInterface();
		gdaia.setInterfaceGUI(gui);
		Thread tgui = new Thread(new Ventana(gui));
		tgui.run();
		*/
		
		// Preparamos las variables assert a comparar
		ConceptoElemental assertConcepto1 = new ConceptoElemental(1, "Soy", Canal.TECLADO);
		ConceptoElemental assertConcepto2 = new ConceptoElemental(1, "Juan", Canal.TECLADO);
		ConceptoElemental assertConcepto3 = new ConceptoElemental(3, "Hola", Canal.TECLADO);
		ConceptoElemental assertConcepto4 = new ConceptoElemental(4, "Tres", Canal.TECLADO);
		ConceptoElemental assertConcepto5 = new ConceptoElemental(5, "P", Canal.TECLADO);
		ConceptoElemental assertConcepto6 = new ConceptoElemental(6, "3", Canal.TECLADO);
		ConceptoElemental assertConcepto7 = new ConceptoElemental(7, "III", Canal.TECLADO);
		ConceptoElemental assertConcepto10 = new ConceptoElemental(10, "4", Canal.TECLADO);
		ConceptoElemental assertConcepto11 = new ConceptoElemental(11, "Cuatro", Canal.TECLADO);
		ConceptoElemental assertConcepto12 = new ConceptoElemental(12, "IV", Canal.TECLADO);
		ConceptoElemental assertConcepto13 = new ConceptoElemental(12, "5", Canal.TECLADO);
		ConceptoElemental assertConcepto14 = new ConceptoElemental(12, "menos", Canal.TECLADO);
		ConceptoElemental assertConcepto15 = new ConceptoElemental(12, "una", Canal.TECLADO);
		
		
		//concepto abstraido: [3, III, Tres]
		ArrayList al = new ArrayList();
		al.add(assertConcepto6);
		al.add(assertConcepto7);
		al.add(assertConcepto4);
		ConceptoElemental assertConcepto8 = new ConceptoElemental(8, al, Canal.TECLADO);
	
		//concepto abstraido: [4, Cuatro, IV]
		ArrayList a2 = new ArrayList();
		a2.add(assertConcepto10);
		a2.add(assertConcepto11);
		a2.add(assertConcepto12);
		ConceptoElemental assertConcepto9 = new ConceptoElemental(9, a2, Canal.TECLADO);
		
		// [Soy, Juan]
		Situacion assertSituacion1 = new Situacion(new ListBuilder().add(assertConcepto1).add(assertConcepto2).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [Hola, Juan]
		Situacion assertSituacion2 = new Situacion(new ListBuilder().add(assertConcepto3).add(assertConcepto2).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [Tres, P]
		Situacion assertSituacion3 = new Situacion(new ListBuilder().add(assertConcepto4).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [P, P, P]
		Situacion assertSituacion4 = new Situacion(new ListBuilder().add(assertConcepto5).add(assertConcepto5).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [3, P]
		Situacion assertSituacion5 = new Situacion(new ListBuilder().add(assertConcepto6).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [III, P]
		Situacion assertSituacion6 = new Situacion(new ListBuilder().add(assertConcepto7).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// situacion abstraida: [[3, III, Tres], P]]
		Situacion assertSituacion7 = new Situacion(new ListBuilder().add(assertConcepto8).add(assertConcepto5).get(), Canal.INT_ABSTRAER_CONCEPTOS);
		//situacion abstraida: [[4, Cuatro, IV], P]]
		Situacion assertSituacion8 = new Situacion(new ListBuilder().add(assertConcepto9).add(assertConcepto5).get(), Canal.INT_ABSTRAER_CONCEPTOS);
		// [4, P]
		Situacion assertSituacion9 = new Situacion(new ListBuilder().add(assertConcepto10).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [Cuatro, P]
		Situacion assertSituacion10 = new Situacion(new ListBuilder().add(assertConcepto11).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [IV, P]
		Situacion assertSituacion11 = new Situacion(new ListBuilder().add(assertConcepto12).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [P, P, P, P]
		Situacion assertSituacion12 = new Situacion(new ListBuilder().add(assertConcepto5).add(assertConcepto5).add(assertConcepto5).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		// [5, P, menos, una, P]
		Situacion assertSituacion13 = new Situacion(new ListBuilder().add(assertConcepto13).add(assertConcepto5).add(assertConcepto14).add(assertConcepto15).add(assertConcepto5).get(), Canal.INT_MAKE_PRESENT_SIT);
		
		//assert de reglas para la lista corta
		// [Soy, Juan] -> [Hola, Juan]
		Regla assertRegla1 = new Regla(-1, null, new Date(),assertSituacion1, null, assertSituacion2, Canal.INT_LERN_RULE);
		// [Tres, P] -> [P, P, P]
		Regla assertRegla2 = new Regla(-1, null, new Date(),assertSituacion3, null, assertSituacion4, Canal.INT_LERN_RULE);
		// [3, P] -> [P, P, P]
		Regla assertRegla3 = new Regla(-1, null, new Date(),assertSituacion5, null, assertSituacion4, Canal.INT_LERN_RULE);
		// [III, P] -> [P, P, P]
		Regla assertRegla4 = new Regla(-1, null, new Date(),assertSituacion6, null, assertSituacion4, Canal.INT_LERN_RULE);
		// [4, P] -> [P, P, P, P]
		Regla assertRegla6 = new Regla(-1, null, new Date(),assertSituacion9, null, assertSituacion12, Canal.INT_LERN_RULE);
		// [Cuatro, P] -> [P, P, P, P]
		Regla assertRegla7 = new Regla(-1, null, new Date(),assertSituacion10, null, assertSituacion12, Canal.INT_LERN_RULE);
		// [IV, P] -> [P, P, P, P]
		Regla assertRegla8 = new Regla(-1, null, new Date(),assertSituacion11, null, assertSituacion12, Canal.INT_LERN_RULE);
		// [5, P, menos, una, P] -> [P, P, P, P] 
		Regla assertRegla9 = new Regla(-1, null, new Date(),assertSituacion13, null, assertSituacion12, Canal.INT_LERN_RULE);

		// regla abstraida: [[3, III, Tres], P] -> [P, P, P]
		Regla assertRegla5 = new Regla(-1, null, new Date(),assertSituacion7, null, assertSituacion4, Canal.INT_LERN_RULE);
		//[[4, Cuatro, IV], P] -> [P, P, P, P]
		Regla assertRegla10 = new Regla(-1, null, new Date(),assertSituacion8, null, assertSituacion12, Canal.INT_LERN_RULE);
		
		
		// LearnRule: Soy Juan -> Hola Juan
		LearnRuleCommandTest learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion1, assertSituacion2, assertRegla1);
		suite.addTest(learnRuleCommandTestNew);
		
		// LearnRule: Tres P -> P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion3, assertSituacion4, assertRegla2);
		suite.addTest(learnRuleCommandTestNew);

		// LearnRule: 3 P -> P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion5, assertSituacion4, assertRegla3);
		suite.addTest(learnRuleCommandTestNew);
		
		// LearnRule: III P -> P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion6, assertSituacion4, assertRegla3);
		suite.addTest(learnRuleCommandTestNew);
						
		// LearnRule: 4 P -> P P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion9, assertSituacion12, assertRegla6);
		suite.addTest(learnRuleCommandTestNew);
		
		// LearnRule: Cuatro P -> P P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion10, assertSituacion12, assertRegla7);
		suite.addTest(learnRuleCommandTestNew);

		// LearnRule: IV P -> P P P P
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion11, assertSituacion12, assertRegla8);
		suite.addTest(learnRuleCommandTestNew);

		// LearnRule: [5, P, menos, una, P] -> [P, P, P, P]
		learnRuleCommandTestNew = new LearnRuleCommandTest("testExecute", gdaia, assertSituacion13, assertSituacion12, assertRegla9);
		suite.addTest(learnRuleCommandTestNew);
		
		ArrayList assertsListasCortas = new ArrayList();
		
		//1
		Set assertListaCorta2 = new HashSet();
		assertListaCorta2.add(null);
		assertsListasCortas.add(assertListaCorta2);
		
		//2
		Set assertListaCorta1 = new HashSet();
		assertListaCorta1.add(assertRegla2);
		assertListaCorta1.add(assertRegla3);
		assertListaCorta1.add(assertRegla4);
		assertListaCorta1.add(assertRegla6);
		assertListaCorta1.add(assertRegla7);
		assertListaCorta1.add(assertRegla8);
		assertListaCorta1.add(assertRegla9);
		assertsListasCortas.add(assertListaCorta1);
		
		//3
		assertsListasCortas.add(assertListaCorta2);
		
		//4
		assertsListasCortas.add(assertListaCorta2);
		
		//5
		assertsListasCortas.add(assertListaCorta1);
		
		//6
		assertsListasCortas.add(assertListaCorta2);
		
		//7
		assertsListasCortas.add(assertListaCorta2);
		
		//8
		assertsListasCortas.add(assertListaCorta1);
		
		//9
		assertsListasCortas.add(assertListaCorta2);
		
		//10
		assertsListasCortas.add(assertListaCorta2);
		
		//11
		assertsListasCortas.add(assertListaCorta1);
		
		//12
		assertsListasCortas.add(assertListaCorta2);
		
		//13
		assertsListasCortas.add(assertListaCorta2);
		
		//14
		assertsListasCortas.add(assertListaCorta1);
		
		//15
		assertsListasCortas.add(assertListaCorta2);
		
		//16
		assertsListasCortas.add(assertListaCorta2);
		
		//17
		assertsListasCortas.add(assertListaCorta1);
		
		//18
		assertsListasCortas.add(assertListaCorta2);
		
		//19
		assertsListasCortas.add(assertListaCorta2);
		
		//20
		assertsListasCortas.add(assertListaCorta1);
		
		//21
		assertsListasCortas.add(assertListaCorta2);
		
		//22
		assertsListasCortas.add(assertListaCorta2);

		//23
		assertsListasCortas.add(assertListaCorta1);
		
		//24
		assertsListasCortas.add(assertListaCorta2);
		
		//25
		assertsListasCortas.add(assertListaCorta2);
		
		//26
		assertsListasCortas.add(assertListaCorta2);
		
		//27
		assertsListasCortas.add(assertListaCorta2);
				
		ArrayList assertsConceptos = new ArrayList();
		assertsConceptos.add(assertConcepto8);
		assertsConceptos.add(assertConcepto9);
		
		ArrayList assertsReglas = new ArrayList();
		assertsReglas.add(assertRegla5);
		assertsReglas.add(assertRegla10);
				
		AbstraerConceptosCommandTest hacerListaCommandTestDormido = new AbstraerConceptosCommandTest("testExecute", gdaia, assertsListasCortas, assertsConceptos, assertsReglas);
		suite.addTest(hacerListaCommandTestDormido);
	
		gdaia.generateXMLForCerebro(gdaia.getCerebro());
		System.out.println("Fin Nuevo Suite de Test");

		// $JUnit-END$
		return suite;
	}
}
